package storage

import (
	"encoding/json"
	"os"
	"sync"
	"time"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/storage"
	"github.com/google/uuid"
)

// HistoryItem 表示一条历史记录
type HistoryItem struct {
	ID         string    `json:"id"`
	Input      string    `json:"input"`
	Corrected  string    `json:"corrected"`
	Suggestion string    `json:"suggestion"`
	Grammer    string    `json:"grammer"`
	Timestamp  time.Time `json:"timestamp"`
}

var (
	history      []HistoryItem
	historyMutex sync.Mutex
	dataFile     fyne.URI
)

var appInstance fyne.App

// SetApp 设置应用实例，供存储模块使用
func SetApp(app fyne.App) {
	appInstance = app
}

// 初始化存储
func init() {
	// 延迟加载历史记录，直到appInstance被设置
	// 实际使用时，应用应该在启动后调用SetApp和LoadHistory
}

// LoadHistory 从存储加载历史记录
func LoadHistory() {
	if appInstance == nil {
		// 如果应用实例未设置，使用空历史记录
		history = []HistoryItem{}
		return
	}

	// 设置数据文件路径
	if dataFile == nil {
		// 获取应用的数据目录
		dataDir := appInstance.Storage().RootURI()
		// 确保数据目录存在
		if err := os.MkdirAll(dataDir.Path(), 0755); err != nil {
			return
		}
		// 构建历史文件URI
		childURI, err := storage.Child(dataDir, "history.json")
		if err != nil {
			return
		}
		dataFile = childURI
	}

	// 尝试打开历史文件
	reader, err := storage.Reader(dataFile)
	if err != nil {
		// 如果文件不存在，创建一个空的历史记录
		history = []HistoryItem{}
		return
	}
	defer reader.Close()

	// 解析JSON数据
	err = json.NewDecoder(reader).Decode(&history)
	if err != nil {
		history = []HistoryItem{}
	}
}

// SaveHistory 保存历史记录
func SaveHistory(input, corrected, suggestion, grammer string) {
	historyMutex.Lock()
	defer historyMutex.Unlock()

	// 创建新的历史记录项
	item := HistoryItem{
		ID:         uuid.NewString(),
		Input:      input,
		Corrected:  corrected,
		Suggestion: suggestion,
		Grammer:    grammer,
		Timestamp:  time.Now(),
	}

	// 添加到历史记录
	history = append(history, item)

	// 保存到文件
	saveHistory()
}

// saveHistory 保存历史记录到存储
func saveHistory() {
	if appInstance == nil || dataFile == nil {
		return
	}

	// 尝试创建或打开历史文件
	writer, err := storage.Writer(dataFile)
	if err != nil {
		return
	}
	defer writer.Close()

	// 序列化历史记录
	enconder := json.NewEncoder(writer)
	enconder.SetIndent("", "  ")
	n := len(history)
	start := 0
	if n > 200 {
		start = n - 200
	}
	if err := enconder.Encode(history[start:]); err != nil {
		return
	}
}

// GetHistory 获取所有历史记录
func GetHistory() []HistoryItem {
	historyMutex.Lock()
	defer historyMutex.Unlock()

	// 返回历史记录的副本
	result := make([]HistoryItem, len(history))
	copy(result, history)
	return result
}

// DeleteHistory 删除指定索引的历史记录
func DeleteHistory(index int) {
	historyMutex.Lock()
	defer historyMutex.Unlock()

	// 检查索引是否有效
	if index < 0 || index >= len(history) {
		return
	}

	// 删除对应的历史记录项
	history = append(history[:index], history[index+1:]...)

	// 保存更新后的历史记录
	saveHistory()
}
